package com.handinfo.uimenu;

import javax.microedition.lcdui.Graphics;

import com.handinfo.engine.AbstractGameScreen;
import com.handinfo.uimenu.window.UIMail;
import com.handinfo.uimenu.window.UIMain;
import com.handinfo.uimenu.window.UIShowData;
import com.handinfo.uimenu.window.UITaskWindow;
import com.handinfo.util.ArrayList;
import com.handinfo.util.Tools;
import com.test.touch.GameTouchManager;
import com.test.touch.TouchDefines;
import com.test.touch.TouchListener;
import com.test.touch.TouchRect;
import com.test.touch.TouchWin;

public abstract class UIAbstractWindow implements TouchWin
{
	/**
	 * 唯一标识
	 */
	public int m_id;

	/**
	 * 坐标和宽高
	 */
	public int m_x, m_y, m_w, m_h;

	/**
	 * 是否占据屏幕焦点
	 */
	protected boolean m_focusable = true;

	/**
	 * 是否需要绘制
	 */
	protected boolean m_isPaint = true;

	/**
	 * 监听器集合
	 */
	private ArrayList m_listeners ;

	/**
	 * 界面状态（层级如下 ：window ，state ，groupId，m_index）
	 */
	protected int m_state;

	/**
	 * 當前界面索引，唯一标示当前处理元素
	 */
	public int m_index = -1;

	/**
	 * 为处理多元素界面提供支持 當前從屬的界面组Id，如处理元素的处理方式相同，可以将其归为一组
	 */
	public int m_groupId;
	/**
	 * 元素所在組的索引 比如一個界面A 有一個狀態 STATEONE 1個狀態有 100個元素 可人为的将其划为5组：组数目可按需求划分 每组里面的组成员长度20，成员长度可按需求划分
	 * 一个元素在界面A,StateOne中Index为20 那么它就是2组的第0个元素
	 */
	public int m_groupIndex;

	public UIAbstractWindow(int id)
	{
		m_id = id;
	}

	/**
	 * 当窗体创建时调用
	 */
	public void createNotify()
	{
		
	}

	/**
	 * 当加入到显示窗体列表中时调用
	 */
	public void showNotify()
	{
//		if (UIManager.getInstance().checkCurFocusedWindow() == 1) {
//			//如果没有，则前面的不是window。
//			GameTouchManager.backUpRect();
//		}
		clearAllRects();
		registerTouch();
//		GameTouchManager.backUpRect(backfile);
	}

	/**
	 * 注册所有触摸区域，在此window加入到列表后showNotify方法里面调用，
	 * 在方法checkCurFocusedWindow后，就是前一个win备份后。
	 * 也可以在其他地方，有的win写法不标准，初始化的时候还不能确定长度什么的。
	 */
	protected void registerTouch() {
		
	}

	/**
	 * 外部更新界面
	 */
	public void updateWindow()
	{

	}

	public void setWindowStatus(int status)
	{
		if (m_state == status) {// 不重复触发当前代码
			return;
		}
		Tools.debugPrintln("WINDOW STATE ="+status);
		m_state = status;
		actionOnStateChanged();
		
//		changeTouchBtn(m_state);
	}
	
//	public abstract void changeTouchBtn(int state);

	/**
	 * 当状态发生修改时可以触发此段代码 若窗体类重写此段代码，则可以实现动态触发，而不需要将代码散落在各个地方 2012-2-17 下午05:06:07 venizeng
	 */
	protected void actionOnStateChanged()
	{

	}

	/**
	 * 设置界面当前选中索引 在发生修改后会触发状态量的切换 同时根据当前状态量会触发索引切换代码
	 */
	protected void setWindowIndex(int index_new)
	{
		if (m_index == index_new) {
			return;
		}
		// 界面数据发生修改
		m_index = index_new;
		m_groupId = countGroupId(m_index);
		m_groupIndex = countGroupIndex(m_groupId, m_index);
		// 触发索引修改代码
		actionOnIndexChanged();
	}

	/**
	 * 当界面索引修改，则触发此段代码 若窗体类重写此段代码，则可以实现动态触发，而不需要将代码散落在各个地方 2012-2-18 上午04:00:18 venizeng
	 */
	protected void actionOnIndexChanged()
	{
	}

	/**
	 * 根据当前索引，划分其组ID 
	 * 即索引到组的映射规则
	 * 2012-2-17 下午05:09:11 venizeng
	 * @param mIndex
	 * @return
	 */
	protected int countGroupId(int mIndex)
	{
		return 0;
	}
	

	/**
	 * 根据当前组内索引，划分其组ID 2012-2-17 下午05:09:11 venizeng
	 * 即根据索引和组获得当前组内索引的规则
	 * @param mIndex
	 * @return
	 */
	protected int countGroupIndex(int mGroupId, int mIndex)
	{
		return 0;
	}
	
	/**
	 * 设置是否绘制
	 * 
	 * @param isPaintAble
	 */
	public void setPaint(boolean isPaintAble)
	{
		m_isPaint = isPaintAble;
	}

	/**
	 * 添加监听器
	 * 
	 * @param listener
	 */
	public void addListener(UIListener listener)
	{
		if (m_listeners == null) {
			m_listeners = new ArrayList();
		}
		m_listeners.addElement(listener);
	}

	/**
	 * 根据指定索引移除监听器
	 * 
	 * @param inx
	 */
	public void removeListenerAt(int inx)
	{
		if (m_listeners == null) {
			return;
		}
		m_listeners.removeElementAt(inx);
	}

	/**
	 * 移除指定监听器
	 * 
	 * @param listener
	 */
	public void removeListener(UIListener listener)
	{
		if (m_listeners == null) {
			return;
		}
		m_listeners.removeElememt(listener);
	}

	/**
	 * 移除所有监听器
	 */
	public void removeAllListener()
	{
		if (m_listeners == null) {
			return;
		}
		m_listeners.removeAllElements();
	}

	/**
	 * 执行监听器逻辑
	 */
	private void execListener()
	{
		if (m_listeners == null) {
			return;
		}
		UIListener listener;
		for (int i = 0, size = m_listeners.size(); i < size; i++) {
			listener = (UIListener) m_listeners.elementAt(i);
			listener.actionPerformed();
		}
	}

	/**
	 * 设置是否占据屏幕焦点
	 */
	public void setFocusable(boolean focusable)
	{
		m_focusable = focusable;
	}

	/**
	 * 设置窗体边界
	 * 
	 * @param x
	 * @param y
	 * @param w
	 * @param h
	 */
	protected void setBounds(int x, int y, int w, int h)
	{
		m_x = x;
		m_y = y;
		m_w = w;
		m_h = h;
	}

	/**
	 * 居中显示
	 */
	public void setCentre()
	{
		m_x = (AbstractGameScreen.SCREEN_WIDTH - m_w) >> 1;
		m_y = (AbstractGameScreen.SCREEN_HEIGHT - m_h) >> 1;
	}

	/**
	 * 设置窗体显示位置
	 * @param x
	 * @param y
	 */
	public void setXY(int x, int y)
	{
		m_x = x;
		m_y = y;
	}

	/**
	 * 与指定窗体比较边界，如果包含指定窗体则返回true
	 * 
	 * @param win
	 * @return
	 */
	protected boolean compareBounds(UIAbstractWindow win)
	{
		if (win.m_x > m_x && win.m_y > m_y && win.m_x + win.m_w < m_x + m_w
				&& win.m_y + win.m_h < m_y + m_h) {
			return true;
		}
		else {
			return false;
		}
	}

	/**
	 * 销毁
	 */
	protected void dispose()
	{
		if (m_listeners != null) {
			m_listeners.removeAllElements();
			m_listeners = null;
		}
	}

	/**
	 * 关闭窗体
	 */
	protected void close()
	{
		dispose();
		UIManager.getInstance().removeWindow(this);
	}

	/**
	 * 给界面加入移除的监听器
	 */
	public void setCloseListener()
	{
		this.addListener(new UIListener() {

			public void actionPerformed()
			{
				if (AbstractGameScreen.haveKeyPressed(AbstractGameScreen.GK_RIGHT_SOFT)) {
					close();
				}
			}
		});
	};

	/**
	 * 仅绘制显示区域内部内容
	 * 
	 * @param g
	 */
	public final void paint(Graphics g)
	{
//		UITools.drawAlphaBG(g);
		int clipX = g.getClipX();
		int clipY = g.getClipY();
		int clipW = g.getClipWidth();
		int clipH = g.getClipHeight();
		g.setClip(m_x, m_y, m_w + 1, m_h + 1);
		if (this instanceof UIMain) {
//			System.out.println(getClass().getName());
		} else if (this instanceof UIShowData) {
			//|| this instanceof UITaskWindow) {
//		}
		} else if (this instanceof UIMessageBox) {
//			System.out.println(getClass().getName());
		} else {
			UITools.drawAlphaBG(g);
//			System.out.println(getClass().getName());
		}
		paintContent(g);
		g.setClip(clipX, clipY, clipW, clipH);
//		g.setColor(0x0000ff);
//		if (mtouchRect!= null) {
//			for(int i=0;i<mtouchRect.size();i++) {
//				TouchRect tr = (TouchRect) mtouchRect.elementAt(i);
//				int[] rect = tr.getRect();
//				if (rect != null) {
//					g.drawRect(rect[0], rect[1], rect[2], rect[3]);
//				}
//			}
//		}
	}

	/**
	 * 绘制内容
	 * 
	 * @param g
	 */
	protected abstract void paintContent(Graphics g);

	/**
	 * 逻辑
	 */
	protected void logic()
	{
		execListener();
		keyLogic();
	}

	/**
	 * 按键逻辑
	 */
	protected abstract void keyLogic();

	/**
	 * 无效触摸区域
	 */
	public static final int TOUCH_NONE = -1;

	/**
	 * 触摸区域集合数组 数组组成结构： 一维：界面状态 二维：触摸区域索引 三维：x,y,w,h
	 */
	public short[][][] m_touchRect;

	/**
	 * 当前触摸区域在触摸区域数组里的索引
	 */
	public int m_touchRectIndex = TOUCH_NONE;

	/**
	 * 触摸逻辑
	 */
	public void touchLogic()
	{
		if (m_touchRect != null && m_touchRect.length > 0) {
			m_touchRectIndex = getTouchRectIndex(m_touchRect[m_state]);
		}
		else {
			m_touchRectIndex = TOUCH_NONE;
		}
	}

	/**
	 * 获得当前触摸区域在触摸区域数组里的索引
	 * 
	 * @param touchRect
	 * @return
	 */
	public int getTouchRectIndex(short[][] touchRect)
	{
		if (touchRect == null || touchRect.length == 0)
			return TOUCH_NONE;
		int x = AbstractGameScreen.getPointX();
		int y = AbstractGameScreen.getPointY();
		for (int i = 0; i < touchRect.length; i++) {
			if (touchRect[i] == null || touchRect.length < 4)
				continue;
			if (x > touchRect[i][0] && x < touchRect[i][0] + touchRect[i][2]
					&& y > touchRect[i][1]
					&& y < touchRect[i][1] + touchRect[i][3]) {
				return i;
			}
		}
		return TOUCH_NONE;
	}
/////////////////////////////////////////////////
//	static final int MAX = 2+10+2+1;
	private ArrayList mtouchRect = new ArrayList(GameTouchManager.MAX,5);
	/**
	 * 注册某些rect的通用方法,注册之后会添加到rects里面，然后在
	 * @see {@link UIAbstractWindow#onTouchRect(int[][], int)}里面实现逻辑。
	 * @param rect
	 */
	public void initTouchRect(final int[][] rect) {
		int size = rect.length;
		for(int i=0;i < size;i ++) {
			final int touchid = i;
			addRect(new TouchRect(rect[i], new TouchListener() {
				public void doTouch(int x, int y) {
//					if (!UIManager.getInstance().getCurFocusedWindow().equals(UIAbstractWindow.this))
//						return;
					onTouchRect(rect, touchid);
				}
			}));
		}
//		GameTouchManager.setTouchWin(this);
	}
	
	private void addRect(TouchRect rect) {
		if (!mtouchRect.contain(rect)) {
			mtouchRect.addElement(rect);
		}
	}
	
	public ArrayList getRects() {
		return mtouchRect;
	}
	
	public final void registerNormalSoft() {
		registerNormalSoft(true, true);
	}
	
	public void registerNormalSoft(boolean left, boolean right) {
		if (left) {
			addRect(new TouchRect(TouchDefines.getLeftSoftRect(), new TouchListener() {
				
				public void doTouch(int x, int y) {
					AbstractGameScreen.s_instance.keyPressed(AbstractGameScreen.LEFT_SOFT);
				}
			}));
		}
		if (right) {
			addRect(new TouchRect(TouchDefines.getRightSoftRect(), new TouchListener() {
				
				public void doTouch(int x, int y) {
					AbstractGameScreen.s_instance.keyPressed(AbstractGameScreen.RIGHT_SOFT);
				}
			}));
		}
	}
	
	
	public void clearAllRects() {
		mtouchRect.removeAllElements();
	}

	/////////////////////////////////////////////////////
	/**
	 * 使用本类initTouchRect(int[][])注册的框，触摸后的具体操作。
	 * @param rect
	 * @param touchid
	 */
	protected void onTouchRect(int[][] rect, int touchid) {
		// TODO Auto-generated method stub
		
	}
	
//	private boolean focus = true;
//	private ArrayList backfile = new ArrayList(10, 5);
//	public boolean isTouchFocus() {
//		return focus;
//	}
//
//	public void setTouchFocus(boolean focus) {
//		if (!this.focus && focus) {//获取焦点还原。
////			onTouchFocusChange(focus);
//			GameTouchManager.recoverRect(backfile);
////			GameTouchManager.setTouchWin(this);
//		} else if (this.focus && !focus) {//失去焦点，备份。
//			GameTouchManager.backUpRect(backfile);
////			onTouchFocusChange(focus);
//		}
//		this.focus = focus;
//	}
//
	/**
	 * 改window从manager里面remove后调用。
	 */
	public void hideNotify() {
////		if (UIManager.getInstance().checkCurFocusedWindow() == 0) {
////			//如果没有，则前面的不是window。
////			GameTouchManager.recoverRect();
////		}
	}
}
